TFG

Indice

• Introducción PENDIENTE
• Metodología
• Fase 1 CRISP-DM: Business Understanding

• Fase 2 CRISP-DM: Data Understanding

  • Fase 2.1: Gathering data
  • Fase 2.2: Describing the data
  • Fase 2.3: Exploring the data
  • Fase 2.4: Verifying data quality

• Fase 3 CRISP-DM: Data Preparation

  • Fase 3.1: Cleaning the data
  • Fase 3.2: Constructing the clean dataset.

• Fase 4 CRISP-DM: Modelling PENDIENTE

• Fase 5 CRISP-DM: Evaluation PENDIENTE

• Fase 6 CRISP-DM: Deployment PENDIENTE

• Bibliografía

Introducción

Metodología

Para la realización de este trabajo voy a seguir la metodología estandar CRISP-DM.

Cross Industry Standard Process for Data Mining (CRISP-DM) es un proceso iterativo de creación de software, centrado en el análisis de datos, dividido en 6 fases:

Business Understanding

En esta fase se intenta clarificar el problema a resolver al igual que los objetivos y limitaciones de nuestra solución.

Data Understanding

En esta fase tenemos que obtener nuestros datos, explorarlos y verificar su calidad.

Data Preparation

En esta fase limpiaremos y formatearemos los datos para maximizar su potencial.

Modeling

En esta fase estudiaremos diferentes formas de realizar los modelos de recomendación y diseñare el modelo.

Evaluation

En esta fase estudiaremos el funcionamiento del modelo

Deployment

En esta fase se detallan los pasos de implementación del sistema en un ambiente profesional y las posibles mejoras.

Phase 1 of the CRISP-DM Process Model: Business Understanding

• A problem that your management wants to address

El objetivo de este Trabajo de Fin de Grado es realizar un sistema de recomendación de películas basado en contenidos (Content-based recommender system), con verificación de recomendaciones basadas en las visualizaciones de otros usuarios.

• The business goals

Este trabajo no tiene un fin comercial. De todos modos, su objetivo comercial sería estudiar las técnicas de sistemas de recomendación y proporcionar una solucíon propia a este problema.

• Constraints (limitations on what you may do, the kinds of solutions that can be used, when the work must be completed, and so on)

La restricción principal de este trabajo es el tiempo.

Debe ser presentado cualquiera de las siguientes tres convocatorias, Febrero, Junio o Septiembre.

• Impact (how the problem and possible solutions fit in with the business)

El impacto de este trabajo será a nivel académico y de demostración de las tecnologías actuales de ML y de sistemas de codificación del lenguaje natural.

Phase 2 of the CRISP-DM Process Model: Data Understanding

2.1 Gathering data

La pagina web de metacritic es un sitio web que recopila reseñas de álbumes de música, videojuegos, películas, programas de televisión y libros.

Para cada categoría de entretenimiento (musica, videojuegos, libros ...), Metacritic dispone de un top donde se encuentran todos los elementos organizados por nota.

En concreto, me voy a centrar en el top de películas (https://www.metacritic.com/browse/movies/score/metascore/all/filtered?page=0).

Este top está dispuesto (actualmente) en 145 páginas, cada uno con entradas correspondientes a 100 películas.

El conjunto de datos ha sido recogido por mi utilizando un programa de webscrapping realizado en python.

En concreto el programa de webscrapping sigue el siguiente esquema:

DiccionarioPeliculas=[]

Para cada numero x de 1 a 145:

    pagina= descargarHTMLPagina(x);

    Para cada numero y de 1 a 100:

        pelicula = descargarHTMLPelicula(y)

        datosPelicula=procesarPelicula(pelicula)

        DiccionarioPeliculas.añadir(datosPelicula)

Para completar nuestra base de datos, nos interesaría mucho disponer de las reviews específicas de los usuarios para cada película que hemos recogido previamente.

Por lo tanto, usando otro programa de webscrapping realizaríamos la siguiente tarea:

PeliculasDeseadas = DiccionarioPeliculas

DiccionarioReviews=[]

Para cada pelicula en DiccionarioPeliculas:

    HTML = descargarHTMLPelicula(pelicula)

    RCs = procesarReviewsCriticos(HTML)

    RUs = procesarReviewsUsers(HTML)

    DiccionarioReviews.añadir(RCs)

    DiccionarioReviews.añadir(RUs)

PENDIENTE: #EXPLICAR EN MAYOR DETALLE EL SCRAPPER

2.2 Describing the data

Primero importaré las librerías necesarias y los datasets de películas y reviews que hemos recopilado en el apartado anterior.

import pandas as pd #Librería pandas para el uso de dataframes
import numpy as np #Libreria Numpy para el uso de operaciones como select
#import seaborn as sns # Librería Seaborn para 
import plotly.express as px #Plotly express para gráficos simples 
import plotly.graph_objects as go #Plotly graphobjects para modificar gráficos  
from nltk.corpus import words # Natural language toolkit para detectar si las reviews están en inglés
import nltk

# Comment this if the data visualisations doesn't work on your side
%matplotlib inline

#Import de los datasets de mi directorio local
dfMovies = pd.read_csv('moviedataset3_11_21.csv')
dfReviews = pd.read_csv('reviewDataSet.csv')

#Descarga del conjunto de datos de palabras en inglés
nltk.download('words')

[nltk_data] Downloading package words to /home/pablo/nltk_data...
[nltk_data]   Package words is already up-to-date!

True

Habiendo importado los datasets a un dataframe de la librería pandas correctamente, usaré el info para mostrar el número de entradas y los atributos de cada dataset.

dfMovies.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 14213 entries, 0 to 14212
Data columns (total 13 columns):
 #   Column       Non-Null Count  Dtype 
---  ------       --------------  ----- 
 0   title        14213 non-null  object
 1   age_rating   14213 non-null  object
 2   rating       14213 non-null  object
 3   rank         14213 non-null  int64 
 4   genre        14213 non-null  object
 5   director     14213 non-null  object
 6   year         14213 non-null  int64 
 7   producer     13941 non-null  object
 8   actor        14213 non-null  object
 9   runtime      14213 non-null  int64 
 10  description  14210 non-null  object
 11  img          14213 non-null  object
 12  url          14213 non-null  object
dtypes: int64(3), object(10)
memory usage: 1.4+ MB

Como podemos ver, disponemos de 13255 entradas con 12 columnas.

Solo 4 de estas columnas son variables discretas, rating, year of release, runtime y rank.

   Rating contiene la nota de 0 a 10 impuesta por los usuarios.

   Rank contiene la posición 1-15000 en la que esta película (impuesto por metacritic)

   Year contiene el año de salida de la película.

   Runtime contiene la duración de la película.

Es esperable que los atributos rating y rank esten fuertemente correlados ya que expresan información muy parecida. Esta afirmación la comprobaré mas tarde, ya que si el valor de correlación es muy alto podríamos considerar un solo atributo.

Por otro lado las variables categóricas son las siguientes:

    Title: contiene el titulo de la película.

    age_rating: indica la edad mínima recomendada para la visualización. Posteriormente haré un análisis para representarla como un entero.

    genre: indica el género.

    director: nombre del director principal de la película.

    producer: nombre de la productora.

    actor: nombre del actor principal de la película.

    description: parrafo con la descripción de la película.

    img: url de la carátula de la película.

    url: url de la página de metacritic donde se describe la película.

Por otro lado, la composición de nuestro dataset de reviews es la siguiente:

dfReviews.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 584150 entries, 0 to 584149
Data columns (total 5 columns):
 #   Column  Non-Null Count   Dtype 
---  ------  --------------   ----- 
 0   title   584150 non-null  object
 1   user    584148 non-null  object
 2   type    584150 non-null  object
 3   grade   584150 non-null  int64 
 4   review  584150 non-null  object
dtypes: int64(1), object(4)
memory usage: 22.3+ MB

Como podemos ver tiene 5 atributos.

Title: string que contiene el nombre de la película que se está puntuando.

User: string que contiene el nombre de usuario del autor de la review.

Type: variable que identifica si el autor es un "reviewer profesional" o un usuario de la web.

Grade: nota de la review.

Review: string que contiene la valoración de la película.

2.3 Exploring data

fig = px.pie(dfMovies, names=dfMovies["genre"].value_counts().index, values=dfMovies["genre"].value_counts())
fig.update_traces(hoverinfo='value', textinfo='label+percent')
fig.update_layout(autosize=False,width=1000,height=1000,)
fig.show();

Como podemos observar, nuestro dataset está compuesto por películas dispuestas en 22 géneros.

El drama es el género más común por grán mayoría. Seguido por acción Acción, documentales y biografías.

Como no vamos a realizar una predicción de genéneros de películas, en principio, este desbalanceo no presentará un problema en el futuro.

Por otra parte, ratings de edad de las películas se disponen de la siguiente forma:

fig = px.bar(dfMovies, x=dfMovies["age_rating"].value_counts().index, y=dfMovies["age_rating"].value_counts())
fig.update_layout(autosize=False,width=1000,height=300,)
fig.show();

Los años de salida siguen la siguiente distribución

fig = px.histogram(dfMovies, x=dfMovies["year"].value_counts().index, y=dfMovies["year"].value_counts(),nbins=130)
fig.update_layout(autosize=False,width=1000,height=300,)
fig.show();

Como podemos observar, desde el año 2000 a habido un crecimiento lineal en la producción de películas, a excepción de 2 parones en los siguientes años:

• 2007-2010: probablemente influenciado por la fuerte crisis económica del momento.
• 2019-202X: probablemente influenciado por el efecto del COVID-19 en la industria del cine.

prodCounts=pd.DataFrame(dfMovies["producer"].value_counts()).head(30)
test_tree = go.Figure(go.Treemap(
    labels =  prodCounts["producer"].index,
    parents=[""]*len(prodCounts["producer"].index),
    values =  prodCounts["producer"].values,
    textinfo = "label+value"
))
test_tree.show();

Para mostrar el tiempo de ejecución voy a usar un diagrama de "caja y bigotes" o boxplot.

El resultado es el siguiente:

fig = px.box(dfMovies, x="runtime", title="Boxplot representativo del tiempo de ejecución.")
fig.show();

Como podemos observar, la mediana en cuanto a duración es 101 minutos.

Los valores extremos se situan en 62 y 144 minutos. Las duraciones fuera de este rango se consideran datos atípicos o outliers.

También vamos a visualizar los 25 actores principales más comunes.

actorCounts=pd.DataFrame(dfMovies["actor"].value_counts())[1:26]
fig = px.pie(actorCounts, names=actorCounts["actor"].index, values=actorCounts["actor"])
fig.update_layout(autosize=False,width=900,height=490,)
fig.update_traces(hoverinfo='value', textinfo='label+percent')

fig.show();

directorCounts=pd.DataFrame(dfMovies["director"].value_counts()).head(25)
z=list(range(1, 26))
fig = go.Figure(data=[go.Bar(
    x=directorCounts["director"].index,
    y=directorCounts["director"],
     marker=dict(color = z, colorscale='Portland'))
])
fig.update_layout(title_text='Top 25 actores');

Con respecto a las notas de las reviews, voy a realizar un boxplot para representar las notas de los usuarios y los reviewers.

fig = px.box(dfReviews, x="grade",y="type")
fig.show()

Como podemos observar, las notas de los reviewers se encuentran en el rango de 0 a 100 y las de los usuarios, de 0 a 10.

Por lo tanto, esto lo tendremos que tener en cuenta en el apartado de data preparation.

También nos interesaría mucho saber si las reviews están en inglés.

Sabemos que las reviews de los usuarios no están filtradas. Por lo tanto para identificar si el idioma de la review es inglés, usaré la libreria Natural Language Toolkit (NLTK).

Primero definiré un conjunto con todas las palabras del idioma inglés que contiene la librería NLTK.

Luego realizaré la intersección de conjuntos de forma que obtendríamos las palabras en inglés de la review.

Por último, usando la longitud original de la review, y la de la intersección, calcularemos el porcentaje de la review que está escrita en inglés.

wordSet=set(words.words())

englishCounter=[]
for index, row in dfReviews.drop_duplicates().iterrows():
    review = row['review'].split()      
    setReview = set(review)
    overlap = wordSet & setReview
    if(len(setReview)>0): #Evitar división entre 0
        englishCounter.append( float(len(overlap)) / len(setReview) * 100)
    else:
        englishCounter.append(0)
fig = px.histogram(pd.DataFrame(englishCounter),nbins=25)
fig.update_layout(autosize=False,width=1000,height=400,)

fig.show()

Como podemos ver, el porcentaje de palabras en inglés sigue una distribución gausiana, centrada en el 75%.

Podríamos considerar que las reviews que tienen un contenido de palabras en inlés menor al 50% no están en inglés.

reviewcounts=pd.DataFrame(dfReviews["title"].value_counts()).head(40)
test_tree = go.Figure(go.Treemap(
    labels =  reviewcounts["title"].index,
    parents=[""]*len(reviewcounts["title"].index),
    values =  reviewcounts["title"].values,
    textinfo = "label+value"
))
test_tree.show();

2.4 Verifying data quality

Para verificar la calidad de nuestros conjuntos de datos verificaré los siguientes criterios:

2.4.1 Unicidad:

Para comprobar la unicidad de nuestros conjuntos de datos podemos utilizar el siguiente método de la librería pandas

Pandas.DataFrame.duplicated() 

Este método, dado un dataframe, devuelve, para cada una de las entradas, si es única o no.

Agrupando este resultado con la función value_counts() obtenemos el siguiente resultado.

print("Reviews duplicadas")
print(dfReviews.duplicated().value_counts())
print("")
print("Peliculas duplicadas")
print(dfMovies.duplicated().value_counts())

Reviews duplicadas
False    583727
True        423
dtype: int64

Peliculas duplicadas
False    14213
dtype: int64

Como podemos observar, existen 423 reviews duplicadas y 0 películas duplicadas.

Por lo tanto, podemos ejecutar la función drop_duplicates() de los dataframes de la librería pandas y eliminar estos valores repetidos.

Si comprobasemos ahora los resultados de la función anterior obtendriamos 0 repetidos.

dfReviews=dfReviews.drop_duplicates()
dfReviews.duplicated().value_counts()

False    583727
dtype: int64

2.4.2 Completitud:

Considero que tanto el dataset de reviews como el de películas son muy completos en cuanto a contenido y numero de entradas.

Ambos datasets contienen todas las entradas en cuanto a películas o críticas disponibles en metacritic.

No existe ninguna dataset publica de Metacritic para la sección de películas. Por lo tanto compararé mi dataset con los 3 datasets de reviews de películas mas "relevantes" según el buscador de Kaggle:

• Numero 1 en relevancia: https://www.kaggle.com/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews
  • 50k entradas, solo incluye contenido de review y un atributo indicando si es positiva o negativa.
• Numero 2 en relevancia: https://www.kaggle.com/utathya/imdb-review-dataset
  • 98k entradas, solo incluye contenido de review y un atributo indicando si es positiva o negativa.
• Numero 3 en relevancia: https://www.kaggle.com/ebiswas/imdb-review-dataset
  • Contenido muy parecido a mi dataset, usuario, titulo, rating, review y variable que indica si incluye spoiler o no.

2.4.3 Validez:

El conjunto de datos de Películas es válido ya que ha sido creado por empleados de metacritic y solo contiene datos factuales.

Por otro lado, algunas atributos son nulos o están por determinar si la película no ha salido todavía al público.

El conjunto de datos de reviews si que puede presentar problemas de validez debido a que las reviews de los usuarios no son filtradas.

2.4.4 Consistencia:

Durante el estudio exploratorio del conjunto de datos he encontrado las siguientes inconsistencias:

• Clasificación de edad:

Las clasificaciones de edad de cada película usan las convenciones particulares de cuando esa película fue grabada.

Por lo tanto, disponemos de 24 labels categóricas que podrían ser remplazadas por unos pocos números enteros.

• Diferentes rangos de puntuación según el tipo de usuario.

Las reviews de los criticos estan sobre 100 en metacritic y las de los users sobre 10.

• Patrones inesperados en las reviews con spoilers

Algunas reviews incluyen la string "This review contains spoilers, click expand to view." indicando que esa review tiene spoilers. Este patrón será eliminado del contenido de la review y indicado en una nueva columna de nuestro dataset.

• Idiomas diferentes en reviews de usuarios

Como hemos visto en el análisis exploratorio, las reviews son mayoritariamente en inglés. De todos modos, existen algunas reviews que su contenido de palabras en inglés es muy bajo, por lo tanto, están en otro idioma (o repletas de faltas de ortografía).

2.4.5 Precisión:

El dataset de películas es preciso ya que ha sido realizado por profesionales encargados de gestionar la página de metacritic.

El dataset de reviews tiene un contendio subjetivo, por lo tanto no podemos medir su precisión. De todos modos cabe destacar que las reviews esta categorizadas por si son de Reviewers o de Usuarios.

• Las reviews de reviewers tendrán un contenido por lo general representativo y bien escrito.

• Las reviews de usuarios no están filtradas, por lo tanto pueden ser tanto muy representativas, como totalmente arbitrarias.

Phase 3 of the CRISP-DM Process Model: Data Preparation

3.1 Cleaning the data

3.1.1 Procesado de la clasificación de edad.

Como hemos podido observar en el gráfico anterior, esta columna está muy desbalanceada, a demas tiene un alto contenido de valores nulos. De todos modos, vamos a realizar data wrangling de forma que agrupamos estas variables categóricas en edades como numeros enteros.

• R, X, son películas indicadas para mayores de edad. Por lo tanto lo sustituiríamos por 18.
• G, TV-G, open y passed son películas para todos los públicos por lo que podemos sustituirlos por 0
• M, TV-PG, PG, M/GP son películas que se indica que debería estar un guardián parental durante su visualización. Podríamos clasificarlas como 15 años.
• PG-13 y PG--13 podemos sustituirlo por 13
• TV-Y7-FV y TV-Y7-FV son películas para 7 años.
• NC-17, MA 17,TV-MA son películas para 17 años.
• Las películas marcadas como approved (hasta 1968) que tienen un contenido moralmente válido. Esto no indica nada pero las marcaremos como 15.
• NR, unrated y Not rated son columnas con valores nulos.

print("Edades antes de procesado",dfMovies["age_rating"].unique() )
df_mod=dfMovies.replace(" | Approved", 15)
df_mod=df_mod.replace(" | R", 18)
df_mod=df_mod.replace(' | TV-G', 0)
df_mod=df_mod.replace(' | TV-PG', 15)
df_mod=df_mod.replace(' | PG', 15)
df_mod=df_mod.replace(' | G', 0)
df_mod=df_mod.replace(' | Passed', 0)
df_mod=df_mod.replace(' | Not Rated', -5)
df_mod=df_mod.replace(' | PG-13', 13)
df_mod=df_mod.replace(' | PG-13`', 13)
df_mod=df_mod.replace(' | GP', 0)
df_mod=df_mod.replace(' | M', 15)
df_mod=df_mod.replace(' | M/PG', 15)
df_mod=df_mod.replace(' | TV-MA', 17)
df_mod=df_mod.replace(' | Unrated', -5)
df_mod=df_mod.replace('Not Rated', -5)
df_mod=df_mod.replace(' | TV-14', 14)
df_mod=df_mod.replace(' | NC-17', 17)
df_mod=df_mod.replace(' | NR', -5)
df_mod=df_mod.replace(' | Open', 14)
df_mod=df_mod.replace(' | X', 18)
df_mod=df_mod.replace(' | MA-17', 14)
df_mod=df_mod.replace(' | PG--13', 13)
df_mod=df_mod.replace(' | TV-Y7-FV', 7)
df_mod=df_mod.replace(' | TV-Y7', 7)
print()
print()
print("Edades despues de procesado",df_mod["age_rating"].unique() )

Edades antes de procesado [' | Approved' ' | R' ' | TV-G' ' | TV-PG' ' | PG' ' | G' ' | Passed'
 ' | Not Rated' ' | PG-13' ' | GP' ' | M' ' | M/PG' ' | TV-MA'
 ' | Unrated' 'Not Rated' ' | TV-14' ' | NC-17' ' | NR' ' | Open' ' | X'
 ' | MA-17' ' | PG--13' ' | PG-13`' ' | TV-Y7-FV' ' | TV-Y7']


Edades despues de procesado [15 18  0 -5 13 17 14  7]

fig = px.bar(df_mod, x=df_mod["age_rating"].value_counts().index, y=df_mod["age_rating"].value_counts())
fig.update_layout(autosize=False,width=700,height=500,)
fig.show();

Como podemos observar, hemos eliminado las variables categóricas y el resultado es mucho mas claro.

Seguimos teniendo una gran cantidad de valores sin calificar (valor -1 en el eje x), sin embargo, como la gran mayoría de valores se encuentran entre 13 y 18 creo que sería buena idea sustituirlo por el valor medio.

print(df_mod['age_rating'].loc[df_mod['age_rating'] > -1].value_counts())
print()
print("El valor medio es ",df_mod['age_rating'].loc[df_mod['age_rating'] > 0].mean(axis=0)," por lo tanto susutituiré las entradas no calificadas por 16")

18    4693
13    2442
15    1654
0      348
17     312
14     146
7        2
Name: age_rating, dtype: int64

El valor medio es  16.044112877067793  por lo tanto susutituiré las entradas no calificadas por 16

df_mod=df_mod.replace(-1, 16)

Esta distribución sería más apropiada teniendo en cuenta los datos no nulos.

3.1.2 Re-escalado de notas de usuarios

Como hemos visto en el apartado 2.3 Exploring data, las calificaciones realizadas por los usuarios se encuentran en el rango de 0 a 10 y las de los críticos en el rango de 0 a 100.

Por lo tanto, vamos a multiplicar las calificaciones de los usuarios por 10 para que todas las calificaciones se encuentren en el mismo intervalo.

def rescaler(x,y):
    if y == "user":
        return x*10
    else:
        return x

dfReviews['grade'] = dfReviews.apply(lambda x: rescaler(x.grade, x.type), axis=1)

Tras aplicar una función lambda, podemos comprobar el resultado con el mismo boxplot que antes.

fig = px.box(dfReviews, x="grade",y="type")
fig.show()

3.1.3 Limpieza de contenido de reviews con spoilers.

Muchas de las reviews de nuestro dataset contienen spoilers.

Metacritic incluye la siguiente subcadena en las reviews con spoilers.

"This review contains spoilers, click expand to view."

print("Reviews que contienen la substring:'This review contains spoilers, click expand to view.' ")
print(dfReviews['review'].str.contains("This review contains spoilers, click expand to view.").value_counts())

Reviews que contienen la substring:'This review contains spoilers, click expand to view.' 
False    567333
True      16394
Name: review, dtype: int64

Eliminaremos esta subcadena de nuestras reviews para eliminar un posible efecto negativo en el algoritmo de vectorización.

De todos modos, añadiremos una nueva columna a nuestro dataset que indique si la review contiene spoilers o no.

conditions = list(map(dfReviews['review'].str.contains, ["This review contains spoilers, click expand to view."]))
dfReviews['spoilers'] =np.select(conditions, ["This review contains spoilers, click expand to view."], 0)
dfReviews.loc[dfReviews['review'].str.contains('This review contains spoilers, click expand to view.'), 'spoilers'] = 1
dfReviews['review']=dfReviews['review'].str.replace("This review contains spoilers, click expand to view.", "")

Para comprobar si el filtrado ha funcionado correctamente volveremos a ejecutar el método contains agrupado por la función value_counts()

print("Reviews que contienen la substring:'This review contains spoilers, click expand to view.' Despues de filtrado")
print(dfReviews['review'].str.contains("This review contains spoilers, click expand to view.").value_counts())

Reviews que contienen la substring:'This review contains spoilers, click expand to view.' Despues de filtrado
False    583727
Name: review, dtype: int64

3.1.4 Indicación de idioma inglés en las reviews.

Para identificar si el idioma de la review es inglés, hemos usado la libreria Natural Language Toolkit (NLTK).

En el análisis exploratorio de datos he creado una lista (englishCounter) que indica el porcentaje de la review que está en inglés.

Esta lista va a ser anexionada como una nueva columna al dataset, para cuando hagamos el modelo, podamos rechazar las entradas con un bajo contenido de palabras en inglés.

dfReviews['englishPct']=englishCounter

3.2 Constructing the clean dataset.

Tras haber limpiado nuestros datasets podemos exportarlos en nuevos ficheros.

#dfReviews.to_csv('reviewDatasetClean.csv',index=False)
#df_mod.to_csv('movieDatasetClean.csv',index=False)

Phase 4 of the CRISP-DM Process Model: Modeling

4.1 Selecting modeling techniques

PENDIENTE: Explicar las diferentes tecnicas de vectorizado y por que considero que son una buena idea para un sistema de recomendación

4.2 Building model(s)

PENDIENTE: Programar el modelo

Phase 5 of the CRISP-DM Process Model: Evaluation

PENDIENTE: Estudiar posibilidades de evaluación y valorar resultados.

Phase 6 of the CRISP-DM Process Model: Deployment

PENDIENTE: ¿pasar de notebook a py y hacer gui?

## BIBLIOGRAFIA

CRISP DM Pete Chapman, Julian Clinton, Randy Kerber, Thomas Khabaza, Thomas Reinartz, Colin Shearer, and Rüdiger Wirth (2000); The CRISP-DM User Guide https://www.the-modeling-agency.com/crisp-dm.pdf

Citar los 3 datasets

Metacritic top

Beautiful soup documentation

La web donde explican lo de STEM,TOR, proxy... </font>